/**
 * 通用工具函数
 * 提供UI交互、时间格式化等通用方法
 */

/**
 * 显示加载状态
 * @param {boolean} isLoading 是否显示加载状态
 * @param {string} loadingElementId 加载元素ID，默认为'loading'
 */
function showLoading(isLoading, loadingElementId = 'loading') {
    const loadingEl = document.getElementById(loadingElementId);
    if (loadingEl) {
        loadingEl.style.display = isLoading ? 'block' : 'none';
    }
}

/**
 * 显示错误信息
 * @param {string} message 错误信息
 * @param {string} errorElementId 错误元素ID，默认为'error-message'
 * @param {number} autoHideDelay 自动隐藏延迟(毫秒)，默认5000ms
 */
function showError(message, errorElementId = 'error-message', autoHideDelay = 5000) {
    console.error(message);
    const errorEl = document.getElementById(errorElementId);
    if (errorEl) {
        errorEl.textContent = message;
        errorEl.style.display = 'block';
        
        // 自动隐藏
        if (autoHideDelay > 0) {
            setTimeout(() => {
                errorEl.style.display = 'none';
            }, autoHideDelay);
        }
    }
}

/**
 * 显示空数据提示
 * @param {string} message 提示消息
 * @param {string} containerSelector 容器选择器，默认为'.main-content'
 */
function showEmpty(message, containerSelector = '.main-content') {
    const container = document.querySelector(containerSelector);
    if (container && container.children.length === 0) {
        const emptyDiv = document.createElement('div');
        emptyDiv.className = 'empty-data';
        emptyDiv.textContent = message;
        container.appendChild(emptyDiv);
    }
}

/**
 * 更新时间显示
 * @param {Date} date 时间对象
 * @param {string} dateSelector 日期元素选择器，默认为'.date'
 * @param {string} timeSelector 时间元素选择器，默认为'.time'
 */
function updateTime(date, dateSelector = '.date', timeSelector = '.time') {
    const dateEl = document.querySelector(dateSelector);
    const timeEl = document.querySelector(timeSelector);
    
    if (dateEl) {
        dateEl.textContent = formatDate(date);
    }
    
    if (timeEl) {
        timeEl.textContent = formatTime(date);
    }
}

/**
 * 格式化日期
 * @param {Date} date 日期对象
 * @returns {string} 格式化后的日期字符串 (yyyy-MM-dd)
 */
function formatDate(date) {
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    return `${year}-${month}-${day}`;
}

/**
 * 格式化时间
 * @param {Date} date 日期对象
 * @returns {string} 格式化后的时间字符串 (HH:mm:ss)
 */
function formatTime(date) {
    const hours = String(date.getHours()).padStart(2, '0');
    const minutes = String(date.getMinutes()).padStart(2, '0');
    const seconds = String(date.getSeconds()).padStart(2, '0');
    return `${hours}:${minutes}:${seconds}`;
}

/**
 * 格式化日期时间
 * @param {Date} date 日期对象
 * @returns {string} 格式化后的日期时间字符串 (yyyy-MM-dd HH:mm:ss)
 */
function formatDateTime(date) {
    return `${formatDate(date)} ${formatTime(date)}`;
}

/**
 * 防抖函数
 * @param {Function} func 要执行的函数 
 * @param {number} delay 延迟时间(毫秒)，默认300ms
 * @returns {Function} 防抖处理后的函数
 */
function debounce(func, delay = 300) {
    let timer = null;
    return function(...args) {
        if (timer) clearTimeout(timer);
        timer = setTimeout(() => {
            func.apply(this, args);
        }, delay);
    };
}

/**
 * 节流函数
 * @param {Function} func 要执行的函数
 * @param {number} limit 限制时间(毫秒)，默认300ms
 * @returns {Function} 节流处理后的函数
 */
function throttle(func, limit = 300) {
    let lastFunc;
    let lastRan;
    return function(...args) {
        if (!lastRan) {
            func.apply(this, args);
            lastRan = Date.now();
        } else {
            clearTimeout(lastFunc);
            lastFunc = setTimeout(() => {
                if (Date.now() - lastRan >= limit) {
                    func.apply(this, args);
                    lastRan = Date.now();
                }
            }, limit - (Date.now() - lastRan));
        }
    };
}

/**
 * 显示消息提示框
 * @param {string} message 消息内容
 * @param {string} type 消息类型，success或error，默认success
 * @param {number} duration 显示时长，默认3000ms
 */
function showMessage(message, type = 'success', duration = 3000) {
    // 创建toast元素
    const toast = document.createElement('div');
    toast.className = `toast toast-${type}`;
    
    // 根据类型设置图标
    let icon = '';
    let bgColor = '';
    let borderColor = '';
    
    switch(type) {
        case 'success':
            icon = '✓';
            bgColor = 'rgba(76, 175, 80, 0.95)';
            borderColor = 'rgba(76, 175, 80, 0.3)';
            break;
        case 'error':
            icon = '✕';
            bgColor = 'rgba(244, 67, 54, 0.95)';
            borderColor = 'rgba(244, 67, 54, 0.3)';
            break;
        case 'warning':
            icon = '⚠';
            bgColor = 'rgba(255, 152, 0, 0.95)';
            borderColor = 'rgba(255, 152, 0, 0.3)';
            break;
        case 'info':
            icon = 'ℹ';
            bgColor = 'rgba(33, 150, 243, 0.95)';
            borderColor = 'rgba(33, 150, 243, 0.3)';
            break;
        default:
            icon = '●';
            bgColor = 'rgba(96, 125, 139, 0.95)';
            borderColor = 'rgba(96, 125, 139, 0.3)';
    }
    
    // 设置toast样式 - 直接定位到底部中心，无任何transform
    toast.style.cssText = `
        position: fixed !important;
        bottom: 80px !important;
        left: 50% !important;
        margin-left: -200px !important;
        width: 400px !important;
        max-width: 90vw !important;
        display: flex !important;
        align-items: center !important;
        gap: 12px !important;
        padding: 16px 24px !important;
        background: ${bgColor} !important;
        border: 1px solid ${borderColor} !important;
        border-radius: 12px !important;
        color: #FFFFFF !important;
        font-size: 15px !important;
        font-weight: 500 !important;
        font-family: 'Roboto', 'PingFang SC', 'Microsoft YaHei', sans-serif !important;
        backdrop-filter: blur(20px) !important;
        -webkit-backdrop-filter: blur(20px) !important;
        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3) !important;
        text-align: left !important;
        opacity: 0 !important;
        transform: none !important;
        transition: opacity 0.3s ease !important;
        animation: none !important;
        pointer-events: auto !important;
        cursor: pointer !important;
        z-index: 10000 !important;
    `;
    
    // 设置内容
    toast.innerHTML = `
        <span style="
            display: inline-flex;
            align-items: center;
            justify-content: center;
            width: 20px;
            height: 20px;
            font-size: 14px;
            font-weight: bold;
            border-radius: 50%;
            background: rgba(255, 255, 255, 0.2);
            flex-shrink: 0;
        ">${icon}</span>
        <span style="flex: 1; line-height: 1.4;">${message}</span>
    `;
    
    // 添加点击关闭功能
    toast.addEventListener('click', () => {
        hideToast(toast);
    });
    
    // 直接添加到body
    document.body.appendChild(toast);
    
    // 触发显示动画 - 只改变透明度
    requestAnimationFrame(() => {
        toast.style.setProperty('opacity', '1', 'important');
        toast.style.setProperty('transform', 'none', 'important');
    });
    
    // 自动隐藏
    const hideTimer = setTimeout(() => {
        hideToast(toast);
    }, duration);
    
    // 鼠标悬停时暂停自动隐藏
    toast.addEventListener('mouseenter', () => {
        clearTimeout(hideTimer);
    });
    
    // 鼠标离开时重新开始倒计时
    toast.addEventListener('mouseleave', () => {
        setTimeout(() => {
            hideToast(toast);
        }, 1000);
    });
    
    // 隐藏toast的函数
    function hideToast(toastElement) {
        if (toastElement && toastElement.parentNode) {
            toastElement.style.setProperty('opacity', '0', 'important');
            toastElement.style.setProperty('transform', 'none', 'important');
            
            setTimeout(() => {
                if (toastElement.parentNode) {
                    toastElement.parentNode.removeChild(toastElement);
                }
            }, 300);
        }
    }
}

// /**
//  * 关闭模态框
//  * @param {string} modalId 模态框ID
//  */
// function closeModal(modalId) {
//     const modal = document.getElementById(modalId);
//     if (modal) {
//         modal.style.display = 'none';
        
//         // 移除事件监听器，防止多次绑定事件
//         const closeBtn = modal.querySelector('.close-modal');
//         const form = modal.querySelector('form');
        
//         if (closeBtn) {
//             const newCloseBtn = closeBtn.cloneNode(true);
//             closeBtn.parentNode.replaceChild(newCloseBtn, closeBtn);
//         }
        
//         if (form) {
//             form.reset();
//         }
//     }
// }

/**
 * 检查并解析JSON响应
 * @param {Object|string} response API响应
 * @returns {Object} 解析后的对象
 */
function parseApiResponse(response) {
    if (!response) return null;
    
    // 如果已经是对象，直接返回
    if (typeof response === 'object' && !Array.isArray(response)) {
        return response;
    }
    
    // 如果是字符串，尝试解析为JSON
    if (typeof response === 'string') {
        try {
            return JSON.parse(response);
        } catch (e) {
            console.error('JSON解析失败:', e);
            return null;
        }
    }
    
    return null;
} 

/**
 * WaromUtils 命名空间对象
 * 包含所有工具函数，方便在其他文件中通过对象引用
 */
const WaromUtils = {
    showLoading,
    showError,
    showEmpty,
    updateTime,
    formatDate,
    formatTime,
    formatDateTime,
    debounce,
    throttle,
    showMessage,
    parseApiResponse
};

// 向全局导出WaromUtils对象
window.WaromUtils = WaromUtils; 